import router from '@/router';
import { ArrayQueryMethod, RBSTEAM, RuleBody } from './baseMethodsClass';
import { itemConfig } from '@/config/base.config';
import os from 'os';
/**
 * @exports ISJSON 判断数据是否为JSON
 * @param param    需要判读的值
 * @returns        true=> 为JSON、false =>不是JSON
 */
export const ISJSON = (param: any) => {
  if (isNullPm(param, true)) return false;
  if (typeof param === 'string') {
    const obj = JSON.parse(param);
    if (typeof obj === 'object' && obj) {
      return true;
    } else {
      return false;
    }
  } else {
    return false;
  }
};

/**
 * @exports routerNewJump router 跳转到新页面的方法|获取页面新跳页面链接的方法
 * @param path            跳转router路径
 * @param query            跳转时的query参数
 * @param link            ==>true 阻止跳转并获取跳转的链接
 * @returns               返回link 或者为空,具体已link 参数为准
 */
export const routerNewJump = (path: string, query: object, link?: boolean): string | void => {
  const newLink = router.resolve({
    path: path, // 跳转的页面路由
    query: {
      // 要传的参数
      ...query,
    },
  });
  if (link) {
    return window.location.origin + newLink.href;
  } else {
    window.open(newLink.href, '_blank'); // 打开新的窗口(跳转路径，跳转类型)
  }
};

/**
 * @export IsPC H5 pc判断
 * @returns     true为PC端，false为手机端
 */
export const IsPC = () => {
  const userAgentInfo = navigator.userAgent;
  const Agents = ['Android', 'iPhone', 'SymbianOS', 'Windows Phone', 'iPad', 'iPod'];
  let steam = true;
  for (let v = 0; v < Agents.length; v++) {
    if (userAgentInfo.indexOf(Agents[v]) > 0) {
      steam = false;
      break;
    }
  }
  return steam;
};

/**
 * @export checkPhone 检查输入的手机号格式是否正确
 * @param phone       传入的手机号码数据
 * @returns           返回值为: true =>手机号正确,false 手机号错误
 */
export const checkPhone = (phone: any) => {
  phone = phone + '';
  let state = true;
  if (phone.length >= 11) {
    const myreg = /^(((13[0-9]{1})|(14[0-9]{1})|(15[0-9]{1})|(17[0-9]{1})|(18[0-9]{1}))+\d{8})$/;
    if (!myreg.test(phone)) {
      state = false;
    }
  } else {
    state = false;
  }
  return state;
};

/**
 * @exports deepCopy 深拷贝
 * @param param      需要copy的值
 * @returns          返回拷贝完的数据
 */
export const deepCopy = (param: any) => {
  return JSON.parse(JSON.stringify(param));
};

/**
 * @exports isNullPm 判断数据,用来判断是否 == '' | == undefined | == null
 * @param param      需要判断的数据
 * @param zero       是否开启对 0 的审核 , true => 开启 | false => 关闭 , 默认为false
 * @returns          当数据为 == '' | == undefined | == null return=>true,否则返回 return =>false
 */
export const isNullPm = (param: any, zero = false) => {
  let state = false;
  if (param === '' || param === undefined || param === null || param === 'null' || Object.keys(param).length === 0) state = true;
  if (zero && (param === 0 || param === '0')) state = true;
  return state;
};

/**
 * @exports randomCoding 随机获取字符串
 * @param n              获取字符串的长度
 * @returns              返回随机字符串
 */
export const randomCoding = (n: number) => {
  //创建26个字母数组
  const arr = [
    'A',
    'B',
    'C',
    'D',
    'E',
    'F',
    'G',
    'H',
    'I',
    'J',
    'K',
    'L',
    'M',
    'N',
    'O',
    'P',
    'Q',
    'R',
    'S',
    'T',
    'U',
    'V',
    'W',
    'X',
    'Y',
    'Z',
  ];
  let idvalue = '';
  for (let i = 0; i < n; i++) {
    idvalue += arr[Math.floor(Math.random() * 26)];
  }
  return idvalue;
};

/**
 * @exports isParam   判断对象数组是否存在某个值(对象数组判断方法) Array<object>
 * @param param       传入的数组
 * @param key         传入的 需要判断的 值
 * @param paramKey    传入的数组 param 想要查询的标识符
 * @returns           state.state 存在 => true | 不存在 => false , state.value 查到的整个对象 ,state.index  对应的下标
 */
export const isParam = (param: Array<object>, key: string, paramKey: string) => {
  const ArrayQueryM = new ArrayQueryMethod({ param, key, paramKey });
  return ArrayQueryM.ArrayQueryMethod;
};

/**
 * @exports isArrayParam 判断数组是否存在某个值(一维数组) Array<stirng | number | boolean>
 * @param param          传入的数组
 * @param key            传入的key
 * @returns              state.state 存在 => true | 不存在 => false , state.value 对应的值 ,state.index  对应的下标
 */
export const isarrayParam = (param: Array<any>, key: string) => {
  const ArrayQueryM = new ArrayQueryMethod({ param, key });
  return ArrayQueryM.ArrayQueryMethod;
};

/**
 * @exports loctionTime 获取本地当前时间
 * @returns             返回时间戳
 */
export const loctionTime = (): number => {
  return Math.round((new Date() as any) / 1000);
};

/**
 * @exports formatDate 时间转化格式
 * @param date         传入的时间戳
 * @param format       时间输出格式
 * 格式说明
 * 对于 2014.09.05 13:14:20
 * yyyy: 年份，2014
 * yy: 年份，14
 * MM: 月份，补满两位，09
 * M: 月份, 9
 * dd: 日期，补满两位，05
 * d: 日期, 5
 * HH: 24制小时，补满两位，13
 * H: 24制小时，13
 * hh: 12制小时，补满两位，01
 * h: 12制小时，1
 * mm: 分钟，补满两位，14
 * m: 分钟，14
 * ss: 秒，补满两位，20
 * s: 秒，20
 * w: 星期，为 [‘日’, ‘一’, ‘二’, ‘三’, ‘四’, ‘五’, ‘六’] 中的某一个
 * @returns  返回对应的时间格式
 */
export const formatDate = (date: any, format: any) => {
  const addZero = (data: any) => {
    if (data < 10) {
      return '0' + data;
    }
    return data;
  };
  const obj: any = {
    yyyy: date.getFullYear(),
    yy: date.getFullYear() % 100,
    MM: addZero(date.getMonth() + 1),
    M: date.getMonth() + 1,
    dd: addZero(date.getDate()),
    d: date.getDate(),
    HH: addZero(date.getHours()),
    H: date.getHours(),
    hh: addZero(date.getHours() % 12),
    h: date.getHours() % 12,
    mm: addZero(date.getMinutes()),
    m: date.getMinutes(),
    ss: addZero(date.getSeconds()),
    s: date.getSeconds(),
    w: (function () {
      const arr = ['日', '一', '二', '三', '四', '五', '六'];
      return arr[date.getDay()];
    })(),
    WW: (function () {
      const arr = ['周日', '周一', '周二', '周三', '周四', '周五', '周六'];
      return arr[date.getDay()];
    })(),
  };
  for (const i in obj) {
    format = format.replace(i, obj[i]);
  }
  return format;
};

/**
 * @exports STDate     通过给定的时间 推算结束日期
 * @param time         EG：2022-08-06 ||  2022-08-06 00:00:00
 * @param day          天数
 * @returns
 */
export const STDate = (time: any, day: any) => {
  const dd = new Date(time);
  dd.setDate(dd.getDate() + (Number(day) - 1)); //获取AddDayCount天后的日期
  return formatDate(dd, 'yyyy-MM-dd');
};

/**
 * @exports timeConversion 时间转化为formatDate 可使用的格式
 * @param time             EG：2022-08-06 ||  2022-08-06 00:00:00
 * @returns
 */
export const timeConversion = (time: number) => {
  const times = new Date(time);
  return times;
};

/**
 * @exports GetParamJoIn GET请求拼接参数使用,用axios自带的GET请求添加不了参数,只能把数据拼上去
 * @param param          Object对象,传进来参数必须是Objeck
 * @returns              返回的是拼接好的字符串值:string,eg '?id=11&&name=22'
 */
export const GetParamJoIn = (param: any) => {
  let d = '?';
  if (param == '' || param == void 0) {
    return '';
  } else {
    /**
     * b    ---->传进来的param对象
     * d    ---->拼接的字符串
     */
    const b: any = Object.keys(param);
    if (b.length !== 0 || b !== undefined || b !== '') {
      for (let c: any = 0; c < b.length; c++) {
        /**
         * `${c === b.length - 1 ? '' : '&&'}` 最后一个参数不添加&
         */
        d += b[c] + '=' + param[b[c]] + `${c === b.length - 1 ? '' : '&'}`;
      }
    }
  }
  return d;
};

/**
 * @exports arraySort 数组排序--用于数组添加或删除后调用的特定方法，覆写key的唯一值
 * @param ListDom     传入的值
 */
export const arraySort = (ListDom: Array<any>) => {
  const lengthC = ListDom.length;
  for (let a = 0; a <= lengthC - 1; a++) {
    ListDom[a].key = randomCoding(6);
  }
};

/**
 * @exports base64ToFile bs64转File
 * @param dataUrl
 * @param name
 * @returns
 */
export const base64ToFile = (urlString: any, fileName: any) => {
  const dataArr = urlString.split(',');
  const byteString = atob(dataArr[1]);
  const options: any = {
    type: 'image/png',
    endings: 'native',
  };
  const u8Arr = new Uint8Array(byteString.length);
  for (let i = 0; i < byteString.length; i++) {
    u8Arr[i] = byteString.charCodeAt(i);
  }
  return new File([u8Arr], fileName + '.png', options); //返回文件流
};

/**
 * @exports checkLicensePlate 车牌号校验-包含新能源车牌
 * @param 车牌
 */
export const checkLicensePlate = (param: any) => {
  const reg =
    /^(([京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领][A-Z](([0-9]{5}[DF])|([DABCEFGHJK]([A-HJ-NP-Z0-9])[0-9]{4})))|([京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领][A-Z][A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9挂学警港澳使领]))$/;
  return reg.test(param);
};

/**
 * @exports phoneFormat 手机号码格式化 eg 156 0000 0000
 * @param param         输入手机号码
 * @returns             返回格式化后的内容 eg 156 0000 0000
 */
export const phoneFormat = (param: any) => {
  if (param == null || param == '') {
    return '';
  }
  const mun = param.split('');
  mun.splice(3, 0, ' ');
  mun.splice(8, 0, ' ');
  return mun.join('');
};

/**
 * @exports arrayDelalike 单一数组，相同数据删除
 * @param                 数组Array<string | number>
 * @returns               返回处理的数据
 */
export const arrayDelalike = (param: Array<string | number>) => {
  const steam = deepCopy(param);
  return Array.from(new Set(steam));
};

/**
 * @exports  arrayStatistics  数组统计相同数据
 * @param param               需要统计的数组
 * @returns                   返回统计完成的数组  mumList.label 数据名称
 *                            mumList.num 数据数量
 */
export const arrayStatistics = (param: Array<any>) => {
  const alikeList: any = [];

  if (param.length > 0) {
    const newList = [...new Set(param)];
    newList.map((res: any) => {
      let num = 0;
      param.map((reb: any) => {
        if (reb == res) {
          num++;
        }
      });
      alikeList.push({
        label: res,
        num: num,
      });
    });
  }
  return alikeList;
};

/**
 * @exports getWidow pc 转 H5缩放
 * @param param 基础宽度
 */
export const getWidow = (param = 1300) => {
  if (!IsPC()) {
    setTimeout(function () {
      const atix: any = window.document.getElementById('atix');
      const oisa: any = window.document.getElementById('oisa');
      const mun = oisa.offsetWidth / param;
      atix.style.transform = `scale(${mun})`;
      atix.style.transformOrigin = `0 -1%`;
      oisa.style.overflowX = `hidden`;
      oisa.style.overflowY = `auto`;
      atix.style.height = atix.offsetHeight * mun + 'px';
    }, 500);
  }
};

/**
 * @exports getYearSrting 年限过滤器
 * @param param
 */
export const getYearSrting = (param) => {
  return isNullPm(param) ? param : param.substring(5, param.length);
};

/**
 * @orderTime 对数据进行时间排序
 */
export const orderTime = (param: any) => {
  param.sort((rea: any, reb: any) => {
    if (rea.startTime < reb.startTime) {
      return -1;
    } else if (rea.startTime > reb.startTime) {
      return 1;
    } else {
      return 0;
    }
  });
  return param;
};

/**
 * @spaceTime        时间差计算工具
 * @param startTime  eg 2006-12-18
 * @param endTime    eg 2006-12-18
 * @returns
 */
export const spaceTime = (startTime: any, endTime: any) => {
  //startTime和endTime是2006-12-18格式
  let dateSpan: any = null;
  let dates: any = null;
  startTime = Date.parse(startTime);
  endTime = Date.parse(endTime);
  dateSpan = endTime - startTime;
  dateSpan = Math.abs(dateSpan);
  dates = Math.floor(dateSpan / (24 * 3600 * 1000));
  return dates;
};

/**
 * @exports ruleLivingExample 京东UI 表单验证继承
 * @param steam
 * @returns
 */
export const ruleLivingExample = (steam: RBSTEAM) => {
  const rbody = new RuleBody(steam);
  return rbody;
};

/**
 * @exports goldConfigOpp 全局方法载入器
 * @param key 配置对应的标识符
 * @param param 需要查询的参数
 * @returns 当配置存在时返回为 true 配置不存在时返回 false
 */
export const goldConfigOpp = (key, param) => {
  return itemConfig()[key].includes(param);
};
